home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / crt / ds3100.md / mon.c < prev    next >
C/C++ Source or Header  |  1990-11-05  |  5KB  |  210 lines
  1. /*
  2.  * mon.c
  3.  *
  4.  *
  5.  *      Profiling stuff for the decStation.
  6.  *
  7.  *
  8.  */
  9.  
  10. #include "gmon.h"
  11.  
  12. extern void monitor();
  13. extern void moncontrol();
  14.  
  15.  
  16. /*
  17.  *----------------------------------------------------------------------
  18.  *
  19.  * _mcount --
  20.  *
  21.  *    This is supposed to record each procedure call, so that gprof
  22.  *      can print a call graph.  But it is just a null procedure because
  23.  *      the mips compiler doesn't use a frame pointer.
  24.  *
  25.  *      Once we switch over to gcc, we will have a frame pointer, and
  26.  *      we will be able to look at the stack and find out who the caller
  27.  *      was.
  28.  *
  29.  * Results:
  30.  *    None.
  31.  *
  32.  * Side effects:
  33.  *    None.
  34.  *
  35.  *----------------------------------------------------------------------
  36.  */
  37.  
  38. void
  39. _mcount()
  40. {
  41.  
  42.     return;
  43. }
  44.  
  45.  
  46.  
  47.     /*
  48.      *    froms is actually a bunch of unsigned shorts indexing tos
  49.      */
  50. extern char        profiling;
  51.  
  52. unsigned short    *froms;
  53. struct tostruct    *tos = 0;
  54. long        tolimit = 0;
  55. char        *s_lowpc = 0;
  56. char        *s_highpc = 0;
  57. unsigned long    s_textsize = 0;
  58. int        s_scale;
  59. char        *minsbrk = 0;
  60.  
  61. static int    ssiz;
  62. static int    *sbuf;
  63.  
  64. #define    MSG "No space for monitor buffer(s)\n"
  65.  
  66. monstartup(lowpc, highpc)
  67.     char    *lowpc;
  68.     char    *highpc;
  69. {
  70.     int            monsize;
  71.     char        *buffer;
  72.     char        *sbrk();
  73.  
  74.     /*
  75.      *    round lowpc and highpc to multiples of the density we're using
  76.      *    so the rest of the scaling (here and in gprof) stays in ints.
  77.      */
  78.     lowpc = (char *)
  79.         ROUNDDOWN((unsigned)lowpc, HISTFRACTION*sizeof(HISTCOUNTER));
  80.     s_lowpc = lowpc;
  81.     highpc = (char *)
  82.         ROUNDUP((unsigned)highpc, HISTFRACTION*sizeof(HISTCOUNTER));
  83.     s_highpc = highpc;
  84.     s_textsize = highpc - lowpc;
  85.     monsize = (s_textsize / HISTFRACTION) + sizeof(struct phdr);
  86.     buffer = sbrk( monsize );
  87.     if ( buffer == (char *) -1 ) {
  88.     write( 2 , MSG , sizeof(MSG) );
  89.     return;
  90.     }
  91.     froms = (unsigned short *) sbrk( s_textsize / HASHFRACTION );
  92.     if ( froms == (unsigned short *) -1 ) {
  93.     write( 2 , MSG , sizeof(MSG) );
  94.     froms = 0;
  95.     return;
  96.     }
  97.     tolimit = s_textsize * ARCDENSITY / 100;
  98.     if ( tolimit < MINARCS ) {
  99.     tolimit = MINARCS;
  100.     } else if ( tolimit > 65534 ) {
  101.     tolimit = 65534;
  102.     }
  103.     tos = (struct tostruct *) sbrk( tolimit * sizeof( struct tostruct ) );
  104.     if ( tos == (struct tostruct *) -1 ) {
  105.     write( 2 , MSG , sizeof(MSG) );
  106.     froms = 0;
  107.     tos = 0;
  108.     return;
  109.     }
  110.     minsbrk = sbrk(0);
  111.     tos[0].link = 0;
  112.     monitor( lowpc , highpc , buffer , monsize , tolimit );
  113. }
  114.  
  115. _mcleanup()
  116. {
  117.     int            fd;
  118.     int            fromindex;
  119.     int            endfrom;
  120.     char        *frompc;
  121.     int            toindex;
  122.     struct rawarc    rawarc;
  123.  
  124.     moncontrol(0);
  125.     fd = creat( "gmon.out" , 0666 );
  126.     if ( fd < 0 ) {
  127.     perror( "mcount: gmon.out" );
  128.     return;
  129.     }
  130. #   ifdef DEBUG
  131.     fprintf( stderr , "[mcleanup] sbuf 0x%x ssiz %d\n" , sbuf , ssiz );
  132. #   endif DEBUG
  133.     write( fd , sbuf , ssiz );
  134.     endfrom = s_textsize / (HASHFRACTION * sizeof(*froms));
  135.     for ( fromindex = 0 ; fromindex < endfrom ; fromindex++ ) {
  136.     if ( froms[fromindex] == 0 ) {
  137.         continue;
  138.     }
  139.     frompc = s_lowpc + (fromindex * HASHFRACTION * sizeof(*froms));
  140.     for (toindex=froms[fromindex]; toindex!=0; toindex=tos[toindex].link) {
  141. #        ifdef DEBUG
  142.         fprintf( stderr ,
  143.             "[mcleanup] frompc 0x%x selfpc 0x%x count %d\n" ,
  144.             frompc , tos[toindex].selfpc , tos[toindex].count );
  145. #        endif DEBUG
  146.         rawarc.raw_frompc = (unsigned long) frompc;
  147.         rawarc.raw_selfpc = (unsigned long) tos[toindex].selfpc;
  148.         rawarc.raw_count = tos[toindex].count;
  149.         write( fd , &rawarc , sizeof rawarc );
  150.     }
  151.     }
  152.     close( fd );
  153. }
  154.  
  155. /*VARARGS1*/
  156. void
  157. monitor( lowpc , highpc , buf , bufsiz , nfunc )
  158.     char    *lowpc;
  159.     char    *highpc;
  160.     int        *buf, bufsiz;
  161.     int        nfunc;    /* not used, available for compatability only */
  162. {
  163.     register o;
  164.  
  165.     if ( lowpc == 0 ) {
  166.     moncontrol(0);
  167.     _mcleanup();
  168.     return;
  169.     }
  170.     sbuf = buf;
  171.     ssiz = bufsiz;
  172.     ( (struct phdr *) buf ) -> lpc = lowpc;
  173.     ( (struct phdr *) buf ) -> hpc = highpc;
  174.     ( (struct phdr *) buf ) -> ncnt = ssiz;
  175.     o = sizeof(struct phdr);
  176.     buf = (int *) ( ( (int) buf ) + o );
  177.     bufsiz -= o;
  178.     if ( bufsiz <= 0 )
  179.     return;
  180.     o = ( ( (char *) highpc - (char *) lowpc) );
  181.     if( bufsiz < o )
  182.     s_scale = ( (float) bufsiz / o ) * 65536;
  183.     else
  184.     s_scale = 65536;
  185.     moncontrol(1);
  186. }
  187.  
  188. /*
  189.  * Control profiling
  190.  *    profiling is what mcount checks to see if
  191.  *    all the data structures are ready.
  192.  */
  193. void
  194. moncontrol(mode)
  195.     int mode;
  196. {
  197.     if (mode) {
  198.     /* start */
  199.     profil((char*) sbuf + sizeof(struct phdr), ssiz - sizeof(struct phdr),
  200.         s_lowpc, s_scale);
  201.     profiling = 0;
  202.     } else {
  203.     /* stop */
  204.     profil((char *)0, 0, 0, 0);
  205.     profiling = 3;
  206.     }
  207.     return;
  208. }
  209.  
  210.